#website
#http://learnxinyminutes.com/docs/perl6/

#Single line comment start with a pound

#`(
	Multiline comments use #` and a qutoing construct.
	(), [], {}, etc, will work
)

###Variables

#In Perl 6, you declare a lexical variable use 'my'
my $variable;

#Perl 6 has 4 kind of variables:

## * Scalars. They represent a single value. They start with  a '$'
my $str = 'String';

#double quotes  allow for interpolation (which we'll see later):
my $str2 = "String";

#variable names can contain but not end with simple quotes and dashes, 
#and can contain (and end with underscores) :
#my $weird'variable-name_ = 5; #works !

my $bool = True; #`True` and `False` are Perl 6's boolean
my $inverse = !$bool; #You can invert a bool with the perfix `!` operator
my $forceed-bool = so $str; #And you can use the prefix `so` operator
							#which turns its operand into a Bool

## * Lists. They represent multiple values. Their name start with `@`.
my @array = 'a', 'b', 'c';

#equivalent to :
my @letters = <a b c>; #array of words, delimited by space.
						#Similar to Perl5's qw, or Ruby's %w.
#@array = 1, 2, 3;

say @array[2]; #Array indices start at 0 -- This is the third element

say 'Interpolate an array using []: @array[]';
#=> Interpolate an array using []: 1 2 3

@array[0] = -1; #Assign a new value to an array index
@array[0, 1] = 5, 6; #Assign multiple values

my @keys = 0, 2;

@array[@keys] = @letters; #Assign using an array
say @array; # -> a 6 b

## * Hashes, or key-value Pairs
# Hashes are actually arrays of Pairs
# (you can construct a Pair object using the syntax `Key => Value`),
# except they get "flattened" (hash context), removing duplicated keys.
my %hash1 =	1 => 2,
			3 => 4;

#my %hash2 = 	autoquoted => "key", #keys get auto-quoted
#			"some other" => "value", #trailing commas are okay
#			;
#my %hash3 = <key1 value1 key2 value2>;  #you can also create a hash 
										# from an even-numbered array
my %hash4 = key1 => 'value1', key2 => 'value2'; #same as this

#You can also use the "colon pair" syntax:
# (especially handy for named parameters that you'll see later)
my %hash5 = :w(1), #equivalent to `w => 1`
			#this is useful for the `True` shortcut:
			:truey, #equivalent to `:truey(True)`, or `truey => True`
			#and for the `False` one:
			:!falsey, #equivalent to `:falsey(False)`, or `falsey => False`
			;

say %hash4{'key1'}; #You can use {} to get the value from a key
say %hash4<key2>; #If it's a string, you can actually use <>
					#(`{key1}` doesn't work , as Perl 6 doesn't have barewords)


## * Subs (subroutines, or functions in most other languages).
# Stored in variable, they use &.

sub say-hello{ say "Hello, world" }

sub say-hello-to(Str $name){ 	#You can provied the type of an argument
								# and it'll be checked at compile-time.
	say "Hello, $name !";
}

##It can also have optional arguments:
sub with-optional($arg?) { # the "?" marks the argument optional
	say "I might return `(Any)` if I don't have an argument passed, 
		or I'll return my argument";
	$arg;
}

with-optional;	#returns Any
with-optional();	#returns Any
with-optional(1);	#returns 1

## You can also given them a default value when they'are not passed:
sub hello-to($name = "Wordld"){
	say "Hello, $name !";
}

hello-to; # => Hello, World !
hello-to(); #=> Hello, World !
hello-to('You'); #=> Hello, You !

## You can also, by using a syntax akin to the one of hashes (yay unified syntax !
## pass *named* arguments to a `sub` .
#They're optional, and will default to "Any" Perl's "null"-like value).
sub with-named($normal-arg, :$named) {
	say $normal-arg + $named;
}

with-named(1, named => 6); #=> 7

# There's one gotcha to be aware of, here:
# If you quote your key, Perl 6 won't be able to see it at compile time,
# and you'll have a single Pair object as a positional parameter, 
# which means this fails:
#with-named(1, 'named' => 6); #error ('named' => 6 ) is a Pair object
with-named(2, :named(5)); # => 7

# To make a named argument mandatory , you can use `?`'s inverse, `!`
sub with-mandatory-named(:$str!) {
	say "$str !";
}

with-mandatory-named(str => "My String"); #=> My String !
#with-mandatory-named; # run time error: "Required named parameter not passed"
#with-mandatory-named(3); #run time error: "Too many positional parameters passed"

##If a sub takes a named boolean argument ...
sub takes-a-bool($name, :$boolx) {
	say "$name takes $boolx .";
}

# ... you can use the same "short boolean" hash syntax:
takes-a-bool('config', :boolx); #config takes True
takes-a-bool('config', :boolx(" LALALA ")); #config takes False

## You can also provide your named arguments with defaults:
sub named-def(:$def = 5) {
	say $def;
}

named-def;# => 5
named-def(def => 16); # => 15


# Since you can omit parenthesis to call a function with no arguments, 
# you need "&" in the name to capture `say-hello` .
#my &s = &say-hello;
#my &other-s = sub {say "Anonymous function !"}
#s;
#other-s;


# A sub can have a  "slurpy" parameter , or "doesn't-matter-how-many"
sub as-many($head, *@rest) { #`*@` (slurpy) will basically "take everything else"
							 # Note: you can have parameters *before* (like here)
							 # a slurpy one, but not *after* .
	say @rest.join(' / ') ~ " !";
}
say as-many('Happy', 'Happy', 'Birthday'); # => Happy / Birthday!
										   # Note that the splat did not consume
										   # the parameter before


## You can call a function with an array using the 
# "argument list flattening " operator `|`
# (it's not actually the only role of this operator, but it's one of them)
sub concat3($a, $b, $c) {
	say "$a, $b, $c";
}					
concat3(|@array); # => a, b, c
				  #`@array` got "flattened" as a part of the argument list				   


### Containers
# In Perl 6, values are actually stored in "containers" .
# The assignment operator asks the container on the left to store the value on
# its right, When passed around, containers are marked as immutable .
# Whic means that, in a function, you'll get an error if you try to
# mutate one of you arguments.
# If you really need to, you can ask for a mutable container using `is rw`:
sub mutate($n is rw) {
	$n++; # `$n ++` error 
	say "\$n is now $n !";
}

# If what you want is a copy instead, use `is copy`.

#A sub itself return a container, which means it can be marked as rw:
my $x = 42;
sub x-store() is rw {$x}
x-store() = 22; # In this case, the parentheses are mandatory
				# (else Perl 6 thinks `x-store` is an identifier)

say $x; # => 22
say x-store(); # => 22

### Control Flow Structures
## Conditionals

# - `if`
# Before talking about `if`, we need to know which values are "Truthy"
#  (represent True), and which are "Falsey" (or "Falsy") -- represent False.
# Only these values are Falsey: 
# () /empty list/, 
# 0 /zero/, 
# "" /empty string/, 
# Nil /Nil/, 
# A type (like `Str` or `Int`) /type/,
#  and of course False itself.
# Every other value is Truthy.
if True {
	say "It's true !";
}

unless False {
	say "It's not false !";
}

# As you can see, you don't need parentheses around conditions.
# However, you do need the brackets around the "body" block:
# if (true) say; # This doesn't work !

# You can also use their postfix versions, with the keyword after:
say "Quite truthy" if  True;

# - Ternary conditional, "?? !!" (like `x ? y : z` in some other languages)
my $a = True ?? "123" !! "XYZ";

say "get a $a";

# - `given`-`when` looks like other languages `switch`, but much more
# powerful thanks to smart matching and thanks to Perl 6's "topic variable", $_.
#
# This variable contains the default argument of a block,
#  a loop's current iteration (unless explicitly named), etc.
#
# `given` simply puts its argument into `$_` (like a block would do),
#  and `when` compares it using the "smart matching" (`~~`) operator.
#
# Since other Perl 6 constructs use this variable (as said before, like `for`,
# blocks, etc), this means the powerful `when` is not only applicable along with
# a `given`, but instead anywhere a `$_` exists.
given "foo bar" {
	say $_; # => foo bar
	when /foo/ { # Don't worry about smart matching yet – just know `when` uses it.
	             # This is equivalent to `if $_ ~~ /foo/` .
	    say "Yay !";
	}
	when $_.chars > 50 { # smart matching anything with True (`$a ~~ True`) is True,
                       	 # so you can also put "normal" conditionals.
                       	 # This when is equivalent to this `if`:
                       	 #  if $_ ~~ ($_.chars > 50) {...}
                       	 # Which means:
                       	 #  if $_.chars > 50 {...}
		say "Quite a long string !";
	}
	default { # same as `when *` (using the Whatever Star)
		say "Something else";
	}
}


## Looping constructs

# - `loop` is an infinite loop if you don't pass it arguments,
# but can also be a C-style `for` loop:

loop {
	say "This is an infinite loop !";
	last; # last breaks out of the loop, like the `break` keyword in other languages
}

loop (my $i = 0;$i < 5;$i++) {
	next if $i == 3; # `next` skips to the next iteration, like `continue`
                   	 # in other languages. Note that you can also use postfix
                   	 # conditionals, loops, etc.
	say "This is a C-style for loop !";
}


# - `for` - Passes through an array
for @array -> $variable {
	say "I've got $variable !";
}

# As we saw with given, for's default "current iteration" variable is `$_`.
# That means you can use `when` in a `for` just like you where in a `given`.
for @array {
	say "I've got $_ !";

	.say;	# This is also allowed.
        	# A dot call with no "topic" (receiver) is sent to `$_` by default

    when $_.chars == 1 {
		say "Quite a letters !";
	}

	$_.say; # the above and this are equivalent.
}

for @array {
  # You can...
  next if $_ eq 3; # Skip to the next iteration (`continue` in C-like languages).
  redo if $_ eq 4; # Re-do the iteration, keeping the same topic variable (`$_`).
  last if $_ eq 5; # Or break out of a loop (like `break` in C-like languages).
}

# The "pointy block" syntax isn't specific to for.
# It's just a way to express a block in Perl6.

if concat3(|@array) -> $result {
	say "The result is $result";
}

### Operators

## Since Perl languages are very much operator-based languages,
## Perl 6 operators are actually just funny-looking subroutines, in syntactic
##  categories, like infix:<+> (addition) or prefix:<!> (bool not).

## The categories are:
# - "prefix": before (like `!` in `!True`).
# - "postfix": after (like `++` in `$a++`).
# - "infix": in between (like `*` in `4 * 3`).
# - "circumfix": around (like `[`-`]` in `[1, 2]`).
# - "post-circumfix": around, after another term (like `{`-`}` in `%hash{'key'}`)

## The associativity and precedence list are explained below.

# Alright, you're set to go !

## * Equality Checking

# - `==` is numeric comparison
#3 == 4; # False
#3 != 4; # True

# - `eq` is string comparison
#'a' eq 'b';
#'a' ne 'b'; # not equal
#'a' !eq 'b'; # same as above

# - `eqv` is canonical equivalence (or "deep equality")
say (1, 2) eqv (1, 3);
say (1, 2) eqv (1, 2);

# - `~~` is smart matching
# For a complete list of combinations, use this table:
# http://perlcabal.org/syn/S03.html#Smart_matching
'a' ~~ /a/; # true if matches regexp
'key' ~~ %hash1; # true if key exists in hash

#say $arg ~~ passed; # `True` if the function, passed `$arg`
                                  # as an argument, returns `True`.

#1 ~~ Int; # "has type" (check superclasses and roles)
#1 ~~ True; # smart-matching against a boolean always returns that boolean
           # (and will warn).


# You also, of course, have `<`, `<=`, `>`, `>=`.
# Their string equivalent are also avaiable : `lt`, `le`, `gt`, `ge`.
#3 > 4;


## * Range constructors
#3 .. 7; # 3 to 7, both included
# `^` on either side them exclusive on that side :
#3 ^..^ 7; # 3 to 7, not included (basically `4 .. 6`)
# This also works as a shortcut for `0..^N`:
^10; # means 0..^10
my @range = 1 ..^ 3;
say @range;

# This also allows us to demonstrate that Perl 6 has lazy/infinite arrays,
#  using the Whatever Star:
my @array-infinte = 1..*; # 1 to Infinite ! `1..Inf` is the same.
say @array-infinte[^10]; # you can pass arrays as subscripts and it'll return
                 #  an array of results. This will print
                 # "1 2 3 4 5 6 7 8 9 10" (and not run out of memory !)
# Note : when reading an infinite list, Perl 6 will "reify" the elements
# it needs, then keep them in memory. They won't be calculated more than once.
# It also will never calculate more elements that are needed.

# An array subscript can also be a closure.
# It'll be called with the length as the argument
my @array-a = 0..19;
say join(' ', @array-a[15..*]); #=> 15 16 17 18 19
# which is equivalent to:
say join(' ', @array-a[-> $n { 15..$n }]);

# You can use that in most places you'd expect, even assigning to an array
my @numbers = ^20;
my @seq = 3, 9 ... * > 95; # 3 9 15 21 27 [...] 81 87 93 99
@numbers[5..*] = 3, 9 ... *; # even though the sequence is infinite,
                             # only the 15 needed values will be calculated.

say @numbers; #=> 0 1 2 3 4 3 9 15 21 [...] 81 87
              # (only 20 values)
say @seq;

## * And, Or
3 && 4; # 4, which is Truthy. Calls `.Bool` on `4` and gets `True`.
0 || False; # False . Calls `.Bool` on `0`

{
	my $a = 1, my $b = 2, my $c = 3;

	## * Short-circuit (and tight) versions of the above
	$a && $b && $c; # Returns the first argument that evaluates to False,
					# or the last argument.
	$a || $b;

	# And because you're going to want them,
	#  you also have compound assignment operators:
	$a *= 2; # multiply and assignment
	$b %%= 5; # divisible by and assignment
	@array .= sort; # calls the `sort` method and assigns the result back

	say $a;say $b;say @array;
}

{
	### More on subs !
	# As we said before, Perl 6 has *really* powerful subs. We're going to see
	# a few more key concepts that make them better than in any other language :-).

	## Unpacking !
	# It's the ability to "extract" arrays and keys (AKA "destructuring").
	# It'll work in `my`s and in parameter lists.
	my ($a, $b) = 1, 2;
	say $a; #=> 1
	my ($, $, $c) = 1, 2, 3; # keep the non-interesting anonymous
	say $c; #=> 3

	my ($head, *@tail) = 1, 2, 3; # Yes, it's the same as with "slurpy subs"
	my (*@small) = 1;

	sub foo(@array [$fst, $snd]) {
	  say "My first is $fst, my second is $snd ! All in all, I'm @array[].";
	  # (^ remember the `[]` to interpolate the array)
	}
	foo(@tail); #=> My first is 2, my second is 3 ! All in all, I'm 2 3
	say @small;

	# If you're not using the array itself, you can also keep it anonymous,
	#  much like a scalar:
	sub first-of-array(@ [$fst, *@__]) {$fst}
	say "Small -> " ~ first-of-array(@small); # => 1
	say "Tail -> " ~ first-of-array(@tail); # Throws an error "Too many positional parameters passed"
                       # (which means the array is too big).
	
	# You can also use a slurp ...
	sub slurp-in-array(@ [$fst, *@rest]) { # You could keep `*@rest` anonymous
		say $fst + @rest.elems; # `.elems` returns a list's length.
                          	    # Here, `@rest` is `(3,)`, since `$fst` holds the `2`.
	}
	slurp-in-array(@tail);

	# You could even extract on a slurpy (but it's pretty useless ;-) .)
	sub print-fst(*@ [$fst]) { say $fst }
	print-fst(1); #=> 1
	#print-fst(1, 2);  # errors with "Too many positional parameters passed"                      
}

{
	# You can also destructure hashes (and classes, which you'll learn about later !)
	# The syntax is basically `%hash-name (:key($variable-to-store-value-in))`.
	# The hash can stay anonymous if you only need the values you extracted.
	sub key-of(% (:value($val), :qua($qua))) {
		say "Got val $val, $qua times .";
	}

	# Then call it with a hash: (you need to keep the brackets for it to be a hash)
	key-of( {value => 'foo', qua => 4});
	#key-of(%hash1); # the same (for an equivalent `%hash`)
}

{
	## The last experssion of a sub is returned automatically
	# (though you may use the `return` keyword, of course):
	sub next-index($n){
		$n + 1;
	}
	say " --! 4 Next index is " ~ next-index(4);

	# This is true for everything, except for the looping constructs
	# (due to preformance reasons) : there's reason to build a list
	# if we're just going to discard all the results.
	# If you still want to build one, you can use the `do` statement prefix:
	# (or the `gather` prefix, which we'll see later)
	sub generate-list($n) {
		do for ^$n { # note the use of the range-to prefix operator `^` (`0..^N`)
			$_ #current loop iteration
		}
	}

	my @list = generate-list(4); 

	say @list; # => (0, 1, 2, 3)	
}

{
	## You can create a lambda with `-> {}` ("pointy block") or `{}` ("block")
	my &lambda = -> $argument { "The argument passed to this lambda is $argument" }
	# `->{}` and `{}` are pretty much the same thing, except that the former can
	# take arguments, and that the later can be mistaken as a hash by the parser.

	say lambda('xx');

	my @array = 1, 2, 3, 7;

	# We can, for example, add 3 to each value of an array using map:
	my @arrayplus3 = map({ $_ + 3}, @array); # $_ is the implicit argument

	say @arrayplus3;

	# A sub (`sub {}`) has different semantics than a block (`{}` or `-> {}`):
	# A block doesn't have a "function context" (though it can have arguments),
	# which means that if you return from it, 
	# you're going to return from the parent function. Compare:
	sub is-in(@array, $elem) {
		# this will produce an array of `True` and `False`:
		# (you can also say `anon sub` for "anonymous subroutine")
		map ({return True if $_ == $elem}, @array);

	}

	sub truthy-array(@array) {
		# this will produce an array of `True` and `False`:
  		# (you can also say `anon sub` for "anonymous subroutine")
		map (sub ($i) {if $i { return True} else {return False} }, @array );
		# ^ the `return` only returns from the anonymous `sub`
	}
}

{
	# You can also use the "whatever star" to create an anonymous function
	# (it'll stop at the furthest operator in the current expression)
	my @array = 1, 2, 3, 7;

	my @arrayplus3  = map(* + 3, @array); # `* + 3` is the same as `{$_ + 3}`
	my @arrayplus3_ = map(* + * + 3, @array); # Same as ` -> $a, $b {$a + $b + 3}`
											  # also `sub ($a, $b) {$a + $b + 3}`

	say @arrayplus3;
	say @arrayplus3_;

	say (*/2)(4); # => 2
				  # Immediately execute the function Whatever created.
	say ((* + 3) / 5)(5); # => 1.6
						  #works even in parens !

	# But if you need to have more than one argument (`$_`)
	#  in a block (without wanting to resort to `-> {}`),
	#  you can also use the implicit argument syntax, `$^` :
	map( {$^a + $^b + 3}, @array); #equivalent to following:
	map(sub ($a, $b) {$a + $b + 3}, @array); # (here with `sub`)

	say ((* + * * 2) * 2)(2, 3);

	# Note : those are sorted lexicographically.
	# `{ $^b / $^a }` is like `-> $a, $b { $b / $a }`
}

{	
	## About types...
	# Perl6 is gradually typed. This means you can specify the type
	#  of your variables/arguments/return types, or you can omit them
	#  and they'll default to "Any".
	# You obviously get access to a few base types, like Int and Str.
	# The constructs for declaring types are "class", "role",
	#  which you'll see later.

	# For now, let us examinate "subset":
	# a "subset" is a "sub-type" with additional checks.
	# For example: "a very big integer is an Int that's greater than 500"
	# You can specify the type you're subtyping (by default, Any),
	#  and add additional checks with the "where" keyword:
	say subset VeryBigInteger of Int where * > 500;

	## Multiple Dispatch
	# Perl 6 can decide which variant of a `sub` to call based on the type of the
	# arguments, or on arbitrary preconditions, like with a type or a `where`:

	# with types
	multi sub sayit(Int $n) { # note the `multi` keyword here
		say "Number is : $n";
	}
	multi sub sayit(Str $s) { # a multi is a `sub` by default
		say "String is : $s";
	}

	sayit("foo"); # prints "String is : foo"
	#sayit(True); # fails at *compile time* with
             	 # "calling 'sayit' will never work with arguments of types ..."

    # with arbitrary precondition (remember subsets?):
	multi is-big(Int $n where * > 50) { "Yes !" } # using a closure
	multi is-big(Int $ where 10..50) { "Quite." } # Using smart-matching
	                                              # (could use a regexp, etc)
	multi is-big(Int $) { "No" }

	say is-big(100);
	say is-big(22);
	say is-big(1);

	subset Even of Int where * %% 2;

	multi odd-or-even(Even) { "Even" } # The main case using the type.
	                                   # We don't name the argument.
	multi odd-or-even($) { "Odd" } # "else"

	say odd-or-even('xx');

	# You can even dispatch based on a positional's argument presence !
	multi with-or-without-you(:$with!) { # You need make it mandatory to
	                                     # be able to dispatch against it.
	  say "I can live ! Actually, I can't.";
	}
	multi with-or-without-you {
	  say "Definitely can't live.";
	}

	with-or-without-you;
}

# This is very, very useful for many purposes, like `MAIN` subs (covered later),
#  and even the language itself is using it in several places.
#
# - `is`, for example, is actually a `multi sub` named `trait_mod:<is>`,
#  and it works off that.
# - `is rw`, is simply a dispatch to a function with this signature:
# sub trait_mod:<is>(Routine $r, :$rw!) {}
#
# (commented because running this would be a terrible idea !)


### Scoping
# In Perl 6, contrarily to many scripting languages (like Python, Ruby, PHP),
#  you are to declare your variables before using them. You know `my`.
# (there are other declarators, `our`, `state`, ..., which we'll see later).
# This is called "lexical scoping", where in inner blocks,
#  you can access variables from outer blocks.
{
	my $foo = 'Foo';

	sub foo {
		my $bar = 'Bar';

		sub bar {
			say "$foo $bar";
		}

		&bar; # return the function
	}

	foo()();

	# As you can see, `$foo` and `$bar` were captured.
	# But if we were to try and use `$bar` outside of `foo`,
	# the variable would be undefined (and you'd get a compile time error).
}

## Perl 6 has another kind of scope : dynamic scope
# They use the twigil (composed sigil) `*` to mark dynamically-scoped variables:
{
	my $*a = 2;

	# Dyamically-scoped variables depend on the current call stack,
	#  instead of the current block depth.
	sub foo {
		my $*foo = 1;
		bar();
	}

	sub bar {
		say $*foo ~ $*a;# `$*a` will be looked in the call stack, and find `foo`'s,
             #  even though the blocks aren't nested (they're call-nested).
             #=> 1
	}

	foo();
}



### Object Model

## Perl 6 has a quite comprehensive object model
# You declare a class with the keyword `class`, fields with `has`,
# methods with `method`. Every field to private, and is named `$!attr`,
# but you have `$.` to get a public (immutable) accessor along with it.
# (using `$.` is like using `$!` plus a `method` with the same name)

# (Perl 6's object model ("SixModel") is very flexible,
# and allows you to dynamically add methods, change semantics, etc ...
# (this will not be covered here, and you should refer to the Synopsis).

{
	class A {
		has $.field; # `$.field` is immutable
					 # From inside the class, use `$!field` to modify it
		has $.other-field is rw; # You can obviously mark a public field `rw`.
		has Int $!private-field = 10;

		method get-value {
			$.field + $!private-field;
		}

		method set-value ($n) {
			#$.field = $n; $ As stated before, you can't use the `$.` immutable version.
			$!field = $n; # This works, because `$!` is always mutable.

			$.other-field = 5; # This works, because `$.other-field` is `rw`. 	
		}

		method !private-method {
			say "This method is private to the class !";
		}
	}

	# Create a new instance of A with $.field set to 5 :
	# Note: you can't set private-field from here (more later on).
	my $a = A.new(field => 5);
	say $a.get-value; #=> 15
	#$a.field = 5; # This fails, because the `has $.field` is immutable
	$a.other-field = 10; # This, however, works, because the public field
	                     #  is mutable (`rw`).

	{
		## Perl 6 also has inheritance (along with multiple inheritance)
		# (though considered a misfeature by many)
		class XX {
			has $.val;

			submethod not-inherited {
				say "This method won't be avaiable on B.";
				say "This is must useful for BUILD, which we'll see later.";
			}

			method bar {$.val * 5}	
		}

		class B is XX { #inheritance uses `is`
			method foo {
				say $.val;
			}

			method bar { # this shadows A's `bar`
				$.val * 10
			}	
		}

		# When you use `my T $var`, `$var` starts off with `T` itself in it,
		# so you can call `new` on it.
		# (`.=` is just the dot-call and the assignment operator :
		# `$a .= b ` is the same as `$a = $a.b`)
		# Also note that `BUILD` (the method called inside `new`)
		# will set parent properies too, so you can pass `val => 6`.

		my B $b .= new(val => 5);

		# $b.not-inherited; # This won't work, for reasons explained above
		$b.foo; # prints 5
		say $b.bar; #=> 50, since it calls B's `bar`

		## Roles are supported too (also called Mixins in other languages)
		role PrintableVal {
		  has $!counter = 0;
		  method print {
		    say $.val;
		  }
		}

		# you "import" a mixin (a "role") with "does":
		class Item does PrintableVal {
		  has $.val;

		  # When `does`-ed, a `role` literally "mixes in" the class:
		  #  the methods and fields are put together, which means a class can access
		  #  the private fields/methods of its roles (but not the inverse !):
		  method access {
		    say $!counter++;
		  }

		  # However, this:
		  # method print {}
		  # is ONLY valid when `print` isn't a `multi` with the same dispatch.
		  # (this means a parent class can shadow a child class's `multi print() {}`,
		  #  but it's an error if a role does)

		  # NOTE: You can use a role as a class (with `is ROLE`). In this case, methods
		  # will be shadowed, since the compiler will consider `ROLE` to be a class.
		}
	}
}

{
	### Exceptions
	# Exceptions are built on top of classes, in the package `X` (like `X::IO`).
	# Unlike many other languages, in Perl 6, you put the `CATCH` block *within* the
	#  block to `try`. By default, a `try` has a `CATCH` block that catches
	#  any exception (`CATCH { default {} }`).
	# You can redefine it using `when`s (and `default`)
	#  to handle the exceptions you want:
	try {
		open 'foo';
		CATCH {
			when X::AdHoc {say "Can not open file !"}
			# Any other exception will be re-raised, since we don't have a `default`
    		# Basically, if a `when` matches (or there's a `default`) marks the exception as
    		#  "handled" so that it doesn't get re-thrown from the `CATCH`.
    		# You still can re-throw the exception (see below) by hand.	
		}
	}

	# You can throw an exception using `die`:
#	die X::AdHoc.new(payload => 'Error !');

	# You can access the last exception with `$!` (usually used in a `CATCH` block)

	# There are also some subtelties to exceptions. Some Perl 6 subs return a `Failure`,
	#  which is a kind of "unthrown exception". They're not thrown until you tried to look
	#  at their content, unless you call `.Bool`/`.defined` on them - then they're handled.
	#  (the `.handled` method is `rw`, so you can mark it as `False` back yourself)
	#
	# You can throw a `Failure` using `fail`. Note that if the pragma `use fatal` is on,
	#  `fail` will throw an exception (like `die`). 

#	fail "foo"; # We're not trying to access the value, so no problem.
#	try {
#	  fail "foo";
#	  CATCH {
#	    default { say "It threw because we try to get the fail's value!" }
#	  }
#	}

	# There is also another kind of exception: Control exceptions.
	# Those are "good" exceptions, which happen when you change your program's flow,
	#  using operators like `return`, `next` or `last`.
	# You can "catch" those with `CONTROL` (not 100% working in Rakudo yet).
}

{
	### Packages
	# Packages are a way to reuse code. Packages are like "namespaces", and any
	#  element of the six model (`module`, `role`, `class`, `grammar`, `subset`
	#  and `enum`) are actually packages. (Packages are the lowest common denomitor)
	# Packages are important - especially as Perl is well-known for CPAN,
	#  the Comprehensive Perl Archive Network.
	# You usually don't use packages directly: you use `class Package::Name::Here;`,
	# or if you only want to export variables/subs, you can use `module`:
#	module Hello::World { # Bracketed form
	                      # If `Hello` doesn't exist yet, it'll just be a "stub",
	                      #  that can be redeclared as something else later.
	  # ... declarations here ...
#	}

#	module Parse::Text; # file-scoped form
#	grammar Parse::Text::Grammar { # A grammar is a package, which you could `use`
#	}
}

{
	# NOTE for Perl 5 users: even though the `package` keyword exists,
	#  the braceless form is invalid (to catch a "perl5ism"). This will error out:
	# package Foo; # because Perl 6 will think the entire file is Perl 5
	# Just use `module` or the brace version of `package`.

	# You can use a module (bring its declarations into scope) with `use`
#	use JSON::Tiny; # if you installed Rakudo* or Panda, you'll have this module
#	say from-json('[1]').perl; #=> [1]

	# As said before, any part of the six model is also a package.
	# Since `JSON::Tiny` uses (its own) `JSON::Tiny::Actions` class, you can use it:
#	my $actions = JSON::Tiny::Actions.new;

	# We'll see how to export variables and subs in the next part:

	### Declarators
	# In Perl 6, you get different behaviors based on how you declare a variable.
	# You've already seen `my` and `has`, we'll now explore the others.


	## * `our` (happens at `INIT` time -- see "Phasers" below)
	# Along with `my`, there are several others declarators you can use.
	# The first one you'll want for the previous part is `our`.
	# (All packagish things (`class`, `role`, etc) are `our` by default)
	# it's like `my`, but it also creates a package variable:
	module Foo::Bar {
		our $n = 1;
		our sub inc {
			our sub avaiable {
				# If you try to make inner `sub`s `our`...
                        # Better know what you're doing (Don't !).
      			say "Don't do that. Seriously. You'd get burned.";
			}

      		my sub unavaiable {# `my sub` is the default
      			say "Can't access me from outside, I'm my !";
			}

			say ++$n; # lexically-scoped variables are still available
		}
	}
	say "Our declare ....";
	say $Foo::Bar::n;
	Foo::Bar::inc;
	Foo::Bar::inc;

	## * `constant` (happens at `BEGIN` time)
	# You can use the `constant` keyword to declare a compile-time variable/symbol:
	constant Pi = 3.14;
	constant $var = 1;

	# And if you're wondering, yes, it can also contain infinite lists.
	constant why-not=5, 15 ... *;
	say why-not[^5]; # => 5 15 25 35 45

	## * `state` (happens at run time, but only once)
	# State variables are only executed one time
	# (they exist in other language such as C as `static`)
	sub fixed-rand {
		state $val = rand;
		say $val;
	}

	fixed-rand for ^10; # will print the same number 10 times

	#Note, however, that they exist separately in different enclosing contexts.
	# If you declare a function with a `state` within a loop, it'll re-create the
	#  variable for each iteration of the loop. See:
	say "Begin state loop" ~ '*' x 50;
	for ^5 -> $a {
	  sub foo {
	    state $val = rand; # This will be a different value for every value of `$a`
	  }
	  for ^5 -> $b {
	    say foo; # This will print the same value 5 times, but only 5.
	             # Next iteration will re-run `rand`.
	  }
	}
	say "Begin state loop" ~ '*' x 50;

	### Phasers
	# Phasers in Perl 6 are blocks that happen at determined points of time in your
	#  program. When the program is compiled, when a for loop runs, when you leave a
	#  block, when an exception gets thrown ... (`CATCH` is actually a phaser !)
	# Some of them can be used for their return values, some of them can't
	#  (those that can have a "[*]" in the beginning of their explanation text).
	# Let's have a look !

	## * Compile-time phasers
	BEGIN { say "[*] Runs at compile time, as soon as possible, only once" }
	CHECK { say "[*] Runs at compile time, instead as late as possible, only once" }

	## * Run-time phasers
	INIT { say "[*] Runs at run time, as soon as possible, only once" }
	END { say "Runs at run time, as late as possible, only once" }

	PRE { say "Asserts a precondition at every block entry, before ENTER (especially useful for loops)" }
	POST { say "Asserts a postcondition at every block exit, after LEAVE (especially useful for loops)" }

	## * Block/exceptions phasers
	sub {
	    KEEP { say "Runs when you exit a block successfully (without throwing an exception)" }
	    UNDO { say "Runs when you exit a block unsuccessfully (by throwing an exception)" }
	}();

	## * Loop phasers
	for ^5 {
	  FIRST { say "[*] The first time the loop is run, before ENTER" }
	  NEXT { say "At loop continuation time, before LEAVE" }
	  LAST { say "At loop termination time, after LEAVE" }
	}


	## * Role/class phasers
	COMPOSE { "When a role is composed into a class. /!\ NOT YET IMPLEMENTED" }

	# They allow for cute trick or clever code ...;
	say "This code took " ~ (time - CHECK time ) ~ "s to run";

	# ... or clever organization:
#	sub do-db-stuff {
#	  ENTER $db.start-transaction; # New transaction everytime we enter the sub
#	  KEEP $db.commit; # commit the transaction if all went well
#	  UNDO $db.rollback; # or rollback if all hell broke loose
#	}
}

{
	### Statement prefixes
	# Those act a bit like phasers: they affect the behavior of the following code.
	# Though, they run in-line with the executable code, so they're in lowercase.
	# (`try` and `start` are theoretically in that list, but explained somewhere else)
	# Note: all of these (except start) don't need explicit brackets `{` and `}`.

	# - `do` (that you already saw) - runs a block or a statement as a term
	# You can't normally use a statement as a value (or "term"):
	#
	#    my $value = if True { 1 } # `if` is a statement - parse error
	#
	# This works:
	my $a = do if True {5} # with `do`, `if` is now a term.

	say $a;

	#- `once` - Makes sure a piece of code only runs once
	for ^5 { once say 1}; # -> 1 # Only prints ... once.

	# Like `state`, they're cloned per-scope
	for ^5 {sub {once say 1}() } # => 1 1 1 1 1 # Prints once per lexical scope

	# - `gather` - Co-routine thread
	# Gather allows you to `take` serveral in array,
	# much like `do` but allows you to take any expression.
	say gather for ^ 5 {
		take $_ * 3 - 1;
		take $_ * 3 + 1;
	}

	say join ',', gather if False {
		take 1;
		take 2;
		take 3;
	} # Doesn't print anything.
}

{
	# - `eager` - Evaluate statement eagerly (forces eager context)
	# Don't try this at home:
	#
	#    eager 1..*; # this will probably hang for a while (and might crash ...).
	#
	# But consider:

	constant thrice = gather for ^3 { say take $_ }; # Doesn't print anything

	# versus:
	constant thrice_ = eager gather for ^3 { say take $_ }; #=> 0 1 2
}

# - `lazy` - Defer actual evaluation until value is fetched (forces lazy context)
# Not yet implemented !!

# - `sink` - An `eager` that discards the results (forces sink context)
constant nilthingie = sink for ^3 { .say } #=> 0 1 2
say nilthingie.perl; #=> Nil

{
	# - `quietly` - Supresses warnings
	# Not yet implemented !

	# - `contend` - Attempts side effects under STM
	# Not yet implemented !

	### More operators thingies !

	## Everybody loves operators ! Let's get more of them

	# The precedence list can be found here:
	# http://perlcabal.org/syn/S03.html#Operator_precedence
	# But first, we need a little explanation about associativity:

	# * Binary operators:
#	$a ! $b ! $c; # with a left-associative `!`, this is `($a ! $b) ! $c`
#	$a ! $b ! $c; # with a right-associative `!`, this is `$a ! ($b ! $c)`
#	$a ! $b ! $c; # with a non-associative `!`, this is illegal
#	$a ! $b ! $c; # with a chain-associative `!`, this is `($a ! $b) and ($b ! $c)`
#	$a ! $b ! $c; # with a list-associative `!`, this is `infix:<>`

	# * Unary operators:
#	!$a! # with left-associative `!`, this is `(!$a)!`
#	!$a! # with right-associative `!`, this is `!($a!)`
#	!$a! # with non-associative `!`, this is illegal
}

{
	## Create your own operators !
	# Okay, you've been reading all of that, so I guess I should try
	#  to show you something exciting.
	# I'll tell you a little secret (or not-so-secret):
	# In Perl 6, all operators are actually just funny-looking subroutines.

	# You can declare an operator just like you declare a sub:
	sub prefix:<win>($winner) { # refer to the operator categories
	                            # (yes, it's the "words operator" `<>`)
	  say "$winner Won !";
	}
	win "The King"; #=> The King Won !
	                # (prefix is before)

	# you can still call the sub with its "full name"
	say prefix:<!>(True); #=> False

	sub postfix:<!>(Int $n) {
	  [*] 2..$n; # using the reduce meta-operator ... See below ;-) !
	}
	say 5!; #=> 120
	        # Postfix operators (after) have to come *directly* after the term.
	        # No whitespace. You can use parentheses to disambiguate, i.e. `(5!)!`


	sub infix:<times>(Int $n, Block $r) { # infix in the middle
	  for ^$n {
	    $r(); # You need the explicit parentheses to call the function in `$r`,
	          #  else you'd be referring at the variable itself, like with `&r`.
	  }
	}
	3 times -> { say "hello" }; #=> hello
	                            #=> hello
	                            #=> hello
	                            # You're very recommended to put spaces
	                            # around your infix operator calls.

	# For circumfix and post-circumfix ones
	sub circumfix:<[ ]>(Int $n) {
	  $n ** $n
	}
	say [5]; #=> 3125
	         # circumfix is around. Again, not whitespace.

	sub postcircumfix:<{ }>(Str $s, Int $idx) {
	  # post-circumfix is
	  # "after a term, around something"
	  $s.substr($idx, 1);
	}
	say "abc"{1}; #=> b
	              # after the term `"abc"`, and around the index (1)

	# This really means a lot -- because everything in Perl 6 uses this.
	# For example, to delete a key from a hash, you use the `:delete` adverb
	#  (a simple named argument underneath):
	%h{$key}:delete;
	# equivalent to:
	postcircumfix:<{ }>(%h, $key, :delete); # (you can call operators like that)
	# It's *all* using the same building blocks!
	# Syntactic categories (prefix infix ...), named arguments (adverbs), ...,
	#  - used to build the language - are available to you.

	# (you are, obviously, recommended against making an operator out of
	# *everything* -- with great power comes great responsibility)
}

{
	## Meta operators !
	# Oh boy, get ready. Get ready, because we're delving deep
	#  into the rabbit's hole, and you probably won't want to go
	#  back to other languages after reading that.
	#  (I'm guessing you don't want to already at that point).
	# Meta-operators, as their name suggests, are *composed* operators.
	# Basically, they're operators that apply another operator.

	## * Reduce meta-operator
	# It's a prefix meta-operator that takes a binary functions and
	#  one or many lists. If it doesn't get passed any argument,
	#  it either return a "default value" for this operator
	#  (a meaningless value) or `Any` if there's none (examples below).
	#
	# Otherwise, it pops an element from the list(s) one at a time, and applies
	#  the binary function to the last result (or the list's first element)
	#  and the popped element.
	#
	# To sum a list, you could use the reduce meta-operator with `+`, i.e.:
	say [+] 1, 2, 3; #=> 6
	# equivalent to `(1+2)+3`
	say [*] 1..5; #=> 120
	# equivalent to `((((1*2)*3)*4)*5)`.

	# You can reduce with any operator, not just with mathematical ones.
	# For example, you could reduce with `//` to get
	#  the first defined element of a list:
	say [//] Nil, Any, False, 1, 5; #=> False
	                                # (Falsey, but still defined)
	# Default value examples:
	say [*] (); #=> 1 
	say [+] (); #=> 0 
	            # meaningless values, since N*1=N and N+0=N.
	say [//];   #=> (Any)
	            # There's no "default value" for `//`.

	# You can also call it with a function you made up, using double brackets:
	sub add($a, $b) { $a + $b }
	say [[&add]] 1, 2, 3; #=> 6	


	## * Zip meta-operator
	# This one is an infix meta-operator than also can be used as a "normal" operator.
	# It takes an optional binary function (by default, it just creates a pair),
	#  and will pop one value off of each array and call its binary function on these
	#  until it runs out of elements. It runs the an array with all these new elements.
	(1, 2) Z (3, 4); # ((1, 3), (2, 4)), since by default, the function makes an array
	1..3 Z+ 4..6; # (5, 7, 9), using the custom infix:<+> function

	# Since `Z` is list-associative (see the list above),
	#  you can use it on more than one list
	(True, False) Z|| (False, False) Z|| (False, False); # (True, False)

	# And, as it turns out, you can also use the reduce meta-operator with it:
	[Z||] (True, False), (False, False), (False, False); # (True, False)

	## And to end the operator list:

	## * Sequence operator
	# The sequence operator is one of Perl 6's most powerful features:
	# it's composed of first, on the left, the list you want Perl 6 to deduce from
	#  (and might include a closure), and on the right, a value or the predicate
	#  that says when to stop (or Whatever for a lazy infinite list).
	my @list = 1, 2, 3 ... 10; # basic deducing
	#my @list = 1, 3, 6 ... 10; # this throws you into an infinite loop,
	                            #  because Perl 6 can't figure out the end
	my @list = 1, 2, 3 ...^ 10; # as with ranges, you can exclude the last element
	                            # (the iteration when the predicate matches).
	my @list = 1, 3, 9 ... * > 30; # you can use a predicate
	                               # (with the Whatever Star, here).
	my @list = 1, 3, 9 ... { $_ > 30 }; # (equivalent to the above)

	my @fib = 1, 1, *+* ... *; # lazy infinite list of fibonacci series,
	                           #  computed using a closure!
	my @fib = 1, 1, -> $a, $b { $a + $b } ... *; # (equivalent to the above)
	my @fib = 1, 1, { $^a + $^b } ... *; #(... also equivalent to the above)
	# $a and $b will always take the previous values, meaning here
	#  they'll start with $a = 1 and $b = 1 (values we set by hand).
	#  then $a = 1 and $b = 2 (result from previous $a+$b), and so on.

	say @fib[^10]; #=> 1 1 2 3 5 8 13 21 34 55
	               # (using a range as the index)
	# Note : as for ranges, once reified, elements aren't re-calculated.
	# That's why `@primes[^100]` will take a long time the first time you print
	#  it, then be instant.
}

{
	### Regular Expressions
	# I'm sure a lot of you have been waiting for this one.
	# Well, now that you know a good deal of Perl 6 already, we can get started.
	# First off, you'll have to forget about "PCRE regexps" (perl-compatible regexps).
	#
	# IMPORTANT: Don't skip them because you know PCRE. They're different.
	# Some things are the same (like `?`, `+`, and `*`),
	#  but sometimes the semantics change (`|`).
	# Make sure you read carefully, because you might trip over a new behavior.
	#
	# Perl 6 has many features related to RegExps. After all, Rakudo parses itself.
	# We're first going to look at the syntax itself,
	#  then talk about grammars (PEG-like), differences between
	#  `token`, `regex` and `rule` declarators, and some more.
	# Side note: you still have access to PCRE regexps using the `:P5` modifier.
	#  (we won't be discussing this in this tutorial, however)
	#
	# In essence, Perl 6 natively implements PEG ("Parsing Expression Grammars").
	# The pecking order for ambiguous parses is determined by a multi-level
	#  tie-breaking test:
	#  - Longest token matching. `foo\s+` beats `foo` (by 2 or more positions)
	#  - Longest literal prefix. `food\w*` beats `foo\w*` (by 1)
	#  - Declaration from most-derived to less derived grammars
	#     (grammars are actually classes)
	#  - Earliest declaration wins

	#say so 'a' ~~ /a/; #=> True
	#say so 'a' ~~ / a /; # More readable with some spaces!

	# In all our examples, we're going to use the smart-matching operator against
	#  a regexp. We're converting the result using `so`, but in fact, it's
	#  returning a `Match` object. They know how to respond to list indexing,
	#  hash indexing, and return the matched string.
	# The results of the match are available as `$/` (implicitly lexically-scoped).
	# You can also use the capture variables (`$0`, `$1`, ... starting at 0, not 1 !).
	#
	# You can also note that `~~` does not perform start/end checking
	#  (meaning the regexp can be matched with just one char of the string),
	#  we're going to explain later how you can do it.
}
{
	# In Perl 6, you can have any alphanumeric as a literal,
	# everything else has to be escaped, using a backslash or quotes.
#	say so 'a|b' ~~ / a '|' b /; # `True`. Wouln't mean the same if `|` wasn't escaped
#	say so 'a|b' ~~ / a \| b /; # `True`. Another way to escape it.

	# The whitespace in a regexp is actually not significant,
	#  unless you use the `:s` (`:sigspace`, significant space) modifier.
#	say so 'a b c' ~~ / a b c /; # `False`. Space is not significant here
#	say so 'a b c' ~~ /:s a b c /; # `True`. We added the modifier `:s` here.

	
	# It is, however, important as for how modifiers (that you're gonna see just below)
	#  are applied ...

	## Quantifying - `?`, `+`, `*` and `**`.
	# - `?` - 0 or 1
#	so 'ac' ~~ / a b c /; # `False`
#	so 'ac' ~~ / a b? c /; # `True`, the "b" matched 0 times.
#	so 'abc' ~~ / a b? c /; # `True`, the "b" matched 1 time.
	
	# ... As you read just before, whitespace is important because it determines
	#  which part of the regexp is the target of the modifier:
#	so 'def' ~~ / a b c? /; # `False`. Only the `c` is optional
#	so 'def' ~~ / ab?c /; # `False`. Whitespace is not significant
#	so 'def' ~~ / 'abc'? /; # `True`. The whole "abc" group is optional.

	# Here (and below) the quantifier applies only to the `b`

	# - `+` - 1 or more
#	so 'ac' ~~ / a b+ c /; # `False`; `+` wants at least one matching
#	so 'abc' ~~ / a b+ c /; # `True`; one is enough
#	so 'abbbbc' ~~ / a b+ c /; # `True`, matched 4 "b"s

	# - `*` - 0 or more
#	so 'ac' ~~ / a b* c /; # `True`, they're all optional.
#	so 'abc' ~~ / a b* c /; # `True`
#	so 'abbbbc' ~~ / a b* c /; # `True`
#	so 'aec' ~~ / a b* c /; # `False`. "b"(s) are optional, not replaceable.

	# - `**` - (Unbound) Quantifier
	# If you squint hard enough, you might understand
	#  why exponentation is used for quantity.
#	so 'abc' ~~ / a b ** 1 c /; # `True` (exactly one time)
#	so 'abc' ~~ / a b ** 1..3 c /; # `True` (one to three times)
#	so 'abbbc' ~~ / a b ** 1..3 c /; # `True`
#	so 'abbbbbbc' ~~ / a b ** 1..3 c /; # `False` (too much)
#	so 'abbbbbbc' ~~ / a b ** 3..* c /; # `True` (infinite ranges are okay)

	# - `<[]>` - Character classes
	# Character classes are the equivalent of PCRE's `[]` classes, but
	#  they use a more perl6-ish syntax:
#	say 'fooa' ~~ / f <[ o a ]>+ /; #=> 'fooa'
	# You can use ranges:
#	say 'aeiou' ~~ / a <[ e..w ]> /; #=> 'aeiou'
	# Just like in normal regexes, if you want to use a special character, escape it
	#  (the last one is escaping a space)
#	say 'he-he !' ~~ / 'he-' <[ a..z \! \  ]> + /; #=> 'he-he !'
	# You'll get a warning if you put duplicate names
	#  (which has the nice effect of catching the wrote quoting:)
#	'he he' ~~ / <[ h e ' ' ]> /; # Warns "Repeated characters found in characters class"

	# You can also negate them ... (equivalent to `[^]` in PCRE)
#	so 'foo' ~~ / <-[ f o ]> + /; # False

	# ... and compose them: :
#	so 'foo' ~~ / <[ a..z ] - [ f o ]> + /; # False (any letter except f and o)
#	so 'foo' ~~ / <-[ a..z ] + [ f o ]> + /; # True (no letter except f and o)
#	so 'foo!' ~~ / <-[ a..z ] + [ f o ]> + /; # True (the + doesn't replace the left part)

	## Grouping and capturing
	# Group: you can group parts of your regexp with `[]`.
	# These groups are *not* captured (like PCRE's `(?:)`).
#	so 'abc' ~~ / a [ b ] c /; # `True`. The grouping does pretty much nothing
#	so 'fooABCABCbar' ~~ / foo [ A B C ] + bar /;
	# The previous line returns `True`.
	# We match the "abc" 1 or more time (the `+` was applied to the group).
	# But this does not go far enough, because we can't actually get back what
	#  we matched.
	# Capture: We can actually *capture* the results of the regexp, using parentheses.
#	so 'fooABCABCbar' ~~ / foo ( A B C ) + bar /; # `True`. (using `so` here, `$/` below)

	# So, starting with the grouping explanations.
	# As we said before, our `Match` object is available as `$/`:
	say $/; # Will print some weird stuff (we'll explain) (or "Nil" if nothing matched).

	# As we also said before, it has array indexing:
	say $/[0]; #=> ｢ABC｣ ｢ABC｣
	           # These weird brackets are `Match` objects.
	           # Here, we have an array of these.
	say $0; # The same as above.

	# Our capture is `$0` because it's the first and only one capture in the regexp.
	# You might be wondering why it's an array, and the answer is simple:
	# Some capture (indexed using `$0`, `$/[0]` or a named one) will be an array
	#  IFF it can have more than one element
	#  (so, with `*`, `+` and `**` (whatever the operands), but not with `?`).
	# Let's use examples to see that:

#	so 'fooABCbar' ~~ / foo ( A B C )? bar /; # `True`
	say $/[0]; #=> ｢ABC｣
	say $0.WHAT; #=> (Match)
	             # It can't be more than one, so it's only a single match object.
#	so 'foobar' ~~ / foo ( A B C )? bar /; #=> True
#	say $0.WHAT; #=> (Nil) ****error****
	             # This capture did not match, so it's empty
#	so 'foobar' ~~ / foo ( A B C ) ** 0..1 bar /; # `True`
#	say $0.WHAT; #=> (Array)
	             # A specific quantifier will always capture an Array,
	             #  may it be a range or a specific value (even 1).

	# The captures are indexed per nesting. This means a group in a group will be nested
	#  under its parent group: `$/[0][0]`, for this code:
#	'hello-~-world' ~~ / ( 'hello' ( <[ \- \~ ]> + ) ) 'world' /;
	say $/[0].Str; #=> hello-~-
	say $/[0][0].Str; #=> -~-

	# This stems from a very simple fact: `$/` does not contain strings, integers or arrays,
	#  it only contains match objects. These contain the `.list`, `.hash` and `.Str` methods.
	#  (but you can also just use `match<key>` for hash access and `match[idx]` for array access)
	say $/[0].list.perl; #=> (Match.new(...),).list
	                     # We can see it's a list of Match objects. Those contain a bunch of infos:
	                     # where the match started/ended, the "ast" (see actions later), etc.
	                     # You'll see named capture below with grammars.

    ## Alternatives - the `or` of regexps
	# WARNING: They are DIFFERENT from PCRE regexps.
#	so 'abc' ~~ / a [ b | y ] c /; # `True`. Either "b" or "y".
#	so 'ayc' ~~ / a [ b | y ] c /; # `True`. Obviously enough ...

	
	# The difference between this `|` and the one you're used to is LTM.
	# LTM means "Longest Token Matching". This means that the engine will always
	#  try to match as much as possible in the strng

#	'foo' ~~ / fo | foo /; # `foo`, because it's longer.

	# To decide which part is the "longest", it first splits the regex in two parts:
	# The "declarative prefix" (the part that can be statically analyzed)
	#  and the procedural parts.

	# Declarative prefixes include alternations (`|`), conjuctions (`&`),
	#  sub-rule calls (not yet introduced), literals, characters classes and quantifiers.
	# The latter include everything else: back-references, code assertions,
	#  and other things that can't traditionnaly be represented by normal regexps.
	#
	# Then, all the alternatives are tried at once, and the longest wins.
	# Exemples:


	# DECLARATIVE | PROCEDURAL
#	/ 'foo' \d+     [ <subrule1> || <subrule2> ] /;
	# DECLARATIVE (nested groups are not a problem)
#	/ \s* [ \w & b ] [ c | d ] /;
	# However, closures and recursion (of named regexps) are procedural.
	# ... There are also more complicated rules, like specificity
	#  (literals win over character classes)

	# Note: the first-matching `or` still exists, but is now spelled `||`
#	'foo' ~~ / fo || foo /; # `fo` now.

	### Extra: the MAIN subroutime
	# The `MAIN` subroutine is called when you run a Perl 6 file directly.
	# It's very powerful, because Perl 6 actually parses the argument
	#  and pass them as such to the sub. It also handles named argument (`--foo`)
	#  and will even go as far as to autogenerate a `--help`
	sub MAIN($name) { say "Hello, $name !" }
	# This produces:
	#    $ perl6 cli.pl
	#    Usage:
	#      t.pl <name> 

	# And since it's a regular Perl 6 sub, you can haz multi-dispatch:
	# (using a "Bool" for the named argument so that we can do `--replace`
	#  instead of `--replace=1`)
	subset File of Str where *.IO.d; # convert to IO object to check the file exists

	multi MAIN('add', $key, $value, Bool :$replace) { ... }
	multi MAIN('remove', $key) { ... }
	multi MAIN('import', File, Str :$as) { ... } # omitting parameter name
	# This produces:
	#    $ perl 6 cli.pl
	#    Usage:
	#      t.pl [--replace] add <key> <value> 
	#      t.pl remove <key>
	#      t.pl [--as=<Str>] import (File)
	# As you can see, this is *very* powerful.
	# It even went as far as to show inline the constants.
	# (the type is only displayed if the argument is `$`/is named)

	###
	### APPENDIX A:
	###
	### List of things
	###

	# It's considered by now you know the Perl6 basics.
	# This section is just here to list some common operations,
	#  but which are not in the "main part" of the tutorial to bloat it up

	## Operators


	## * Sort comparison
	# They return one value of the `Order` enum : `Less`, `Same` and `More`
	#  (which numerify to -1, 0 or +1).
	1 <=> 4; # sort comparison for numerics
	'a' leg 'b'; # sort comparison for string
	$obj eqv $obj2; # sort comparison using eqv semantics

	## * Generic ordering
	3 before 4; # True
	'b' after 'a'; # True

	## * Short-circuit default operator
	# Like `or` and `||`, but instead returns the first *defined* value :
	say Any // Nil // 0 // 5; #=> 0

	## * Short-circuit exclusive or (XOR)
	# Returns `True` if one (and only one) of its arguments is true
	say True ^^ False; #=> True
	
	## * Flip Flop
	# The flip flop operators (`ff` and `fff`, equivalent to P5's `..`/`...`).
	#  are operators that take two predicates to test:
	# They are `False` until their left side returns `True`, then are `True` until
	#  their right side returns `True`.
	# Like for ranges, you can exclude the iteration when it became `True`/`False`
	#  by using `^` on either side.
	# Let's start with an example :
	for <well met young hero we shall meet later> {
	  # by default, `ff`/`fff` smart-match (`~~`) against `$_`:
	  if 'met' ^ff 'meet' { # Won't enter the if for "met"
	                        #  (explained in details below).
	    .say
	  }

	  if rand == 0 ff rand == 1 { # compare variables other than `$_`
	    say "This ... probably will never run ...";
	  }
	}
	# This will print "young hero we shall meet" (excluding "met"):
	#  the flip-flop will start returning `True` when it first encounters "met"
	#  (but will still return `False` for "met" itself, due to the leading `^`
	#   on `ff`), until it sees "meet", which is when it'll start returning `False`.

	# The difference between `ff` (awk-style) and `fff` (sed-style) is that
	#  `ff` will test its right side right when its left side changes to `True`,
	#  and can get back to `False` right away
	#  (*except* it'll be `True` for the iteration that matched) -
	# While `fff` will wait for the next iteration to
	#  try its right side, once its left side changed:
	.say if 'B' ff 'B' for <A B C B A>; #=> B B
	                                    # because the right-hand-side was tested
	                                    # directly (and returned `True`).
	                                    # "B"s are printed since it matched that time
	                                    #  (it just went back to `False` right away).
	.say if 'B' fff 'B' for <A B C B A>; #=> B C B
	                                    # The right-hand-side wasn't tested until
	                                    #  `$_` became "C"
	                                    # (and thus did not match instantly).

	# A flip-flop can change state as many times as needed:
	for <test start print it stop not printing start print again stop not anymore> {
	  .say if $_ eq 'start' ^ff^ $_ eq 'stop'; # exclude both "start" and "stop",
	                                           #=> "print this printing again"
	}

	# you might also use a Whatever Star,
	# which is equivalent to `True` for the left side or `False` for the right:
	for (1, 3, 60, 3, 40, 60) { # Note: the parenthesis are superfluous here
	                            # (sometimes called "superstitious parentheses")
	 .say if $_ > 50 ff *; # Once the flip-flop reaches a number greater than 50,
	                       #  it'll never go back to `False`
	                       #=> 60 3 40 60
	}

	# You can also use this property to create an `If`
	#  that'll not go through the first time :
	for <a b c> {
	  .say if * ^ff *; # the flip-flop is `True` and never goes back to `False`,
	                   #  but the `^` makes it *not run* on the first iteration
	                   #=> b c
	}


	# - `===` is value identity and uses `.WHICH` on the objects to compare them
	# - `=:=` is container identity and uses `VAR()` on the objects to compare them
